---
{
	"title": "Gabarit conditionnel",
	"language": "fr",
	"category": "Plugiciels",
	"description": "Association et insertion de contenu JSON tout en suivant un gabarit conditionnel.",
	"tag": "data-json",
	"parentdir": "wb-data-json",
	"altLangPage": "conditional-en.html",
	"dateModified": "2023-06-07"
}
---
<nav>
	<ul>
		<li><a href="data-json-fr.html">Data JSON</a></li>
		<li><a href="template-fr.html">Gabarit HTML 5</a></li>
		<li>(Cette page) Gabarit conditionnel</li>
	</ul>
</nav>

<p>Association et insertion de contenu JSON tout en suivant un gabarit conditionnel.</p>

<p>La liste suivante est un exemple d'association conditionnel en devinant le type de données.</p>

<ul data-wb-json='{
	"url": "demo/conditional-1.json#/subject",
	"mapping": [
		{
			"template": "[data-text]",
			"test": "fn:guessType",
			"expect": "xsd:string",
			"assess": "/foo",
			"mapping": [
				{ "selector": "[data-foo]", "value": "/foo" },
				{ "selector": "[data-bar]", "value": "/bar" }
			]
		},
		{
			"template": "[data-link]",
			"test": "fn:guessType",
			"expect": "xsd:anyURI",
			"assess": "/foo",
			"mapping": [
				{ "selector": "a", "value": "/foo", "attr": "href" },
				{ "selector": "a", "value": "/bar" }
			]
		}
	]
}'>
	<template data-text>
		<li><span data-foo></span> - <span data-bar></span></li>
	</template>
	<template data-link>
		<li><a href></a></li>
	</template>
</ul>

<details>
	<summary>Code source de l'example précédent</summary>
	<p>Json:</p>
	<pre><code>{
	"subject": [
		{
			"foo": "bar",
			"bar": "hello world"
		},
		{
			"foo": "https://example.com",
			"bar": "hello world"
		}
	]
}</code></pre>

<p>Html:</p>
<pre><code>&lt;ul data-wb-json='{
	"url": "demo/conditional-1.json#/subject",
	"mapping": [
		{
			"template": "[data-text]",
			"test": "fn:guessType",
			"expect": "xsd:string",
			"assess": "/foo",
			"mapping": [
				{ "selector": "[data-foo]", "value": "/foo" },
				{ "selector": "[data-bar]", "value": "/bar" }
			]
		},
		{
			"template": "[data-link]",
			"test": "fn:guessType",
			"expect": "xsd:anyURI",
			"assess": "/foo",
			"mapping": [
				{ "selector": "a", "value": "/foo", "attr": "href" },
				{ "selector": "a", "value": "/bar" }
			]
		}
	]
}'>
	&lt;template data-text>
		&lt;li>&lt;span data-foo>&lt;/span> - &lt;span data-bar>&lt;/span>&lt;/li>
	&lt;/template>
	&lt;template data-link>
		&lt;li>&lt;a href>&lt;/a>&lt;/li>
	&lt;/template>
&lt;/ul></code></pre>
</details>


<p>À travers des exemples suivants, il montre également l'utilisation de ces configurations, sans s'y limiter. Une liste complète de toutes les configurations est disponible dans la documentation du plugin data-json.</p>
<dl class="dl-horizontal">
	<dt>Configuration <code>streamline</code></dt>
	<dd>(Booléen: vrai ou faux) Cet indicateur indique que le plugin data-json appliquera le gabarit via l'objet d'association directement, sans essayer d'itérer la source de données.</dd>

	<dt>Object d'association <code>assess</code></dt>
	<dd>(Pointeur JSON) C'est la valeur qui sera prise pour effectuer l'évaluation conditionnelle. Alternativement, elle prendra la valeur de la propriété <code>value</code>. Une autre différence est que <code>assess</code> ne sera pas itéré par rapport à <code>value</code> qui lui sera itéré pour la correspondance interne.</dd>
</dl>

<p>Note : Le gabarit conditionnel considérera les données associées à la propriété <code>@value</code> comme la valeur de son parent correspondant. Quelques exemples utilise cette fonctionnalité d'association automatique, ce qui facilite l'interopérabilité avec des objets typés tels que définis dans la norme JSON-LD.</p>

<details>
	<summary>Code source des fichiers JSON utilisé par les examples dans cette page-ci</summary>
	<div class="row">
		<div class="col-md-6">
			<p>Fichier: conditional-1.json</p>
			<pre><code>{
	"subject": [
		{
			"foo": "bar",
			"bar": "hello world"
		},
		{
			"foo": "https://example.com",
			"bar": "hello world"
		}
	],
	"list": [
		{
			"@type": "xsd:string",
			"@value": "string"
		},
		{
			"@type": "xsd:double",
			"@value": 123.45
		},
		{
			"@type": "xsd:boolean",
			"@value": true
		},
		{
			"@type": "xsd:anyURI",
			"@value": "https://example.com"
		},
		{
			"@type": "xsd:string",
			"@value": "second string"
		}
	],
	"text": {
		"alpha": "alpha",
		"beta": "beta",
		"gamma": "gamma",
		"delta": "delta"
	}
}</code></pre>
		</div>
		<div class="col-md-6">
			<p>Fichier: conditional-2.json</p>
			<pre><code>{
	"alpha": [ "alpha" ],
	"beta": "beta",
	"gamma": { "@value": "gamma" },
	"delta": { "@type": "rdfs:Resource", "@value": "delta" },
	"epsilon": "epsilon",
	"zeta": true,
	"eta": "http://example.com",
	"theta": 123.45,
	"iota": {
		"@type": [ "rdfs:Resource", "xsd:string" ],
		"@value": "iota"
	},
	"kappa": {
		"lamdba": "mu"
	},
	"nu": {
		"@type": "@json",
		"@value": {
			"xi": "xi",
			"omicron": "omicron",
			"pi": "pi"
		}
	},
	"rho": {
		"@type": "@json",
		"@value": {
			"sigma": "sigma",
			"tau": "tau",
			"upsilon": "upsilon"
		}
	},
	"sigma": {
		"alpha": "sigma",
		"gamma": "sigma"
	},
	"undefined": "tau",

	"text": {
		"zeta": "zeta",
		"eta": "eta",
		"theta": "theta",
		"kappa": "kappa"
	}
}</code></pre>
		</div>
	</div>
</details>

<h2>Fonctions de test qui extraient une valeur testable.</h2>
<p>Ces tests nécessitent un pointeur de données fourni soit avec la propriété <code>value</code>, qui itérera également, soit avec <code>assess</code> qui n'itérera pas.</p>

<dl class="dl-horizontal">
	<dt><code>fn:isArray</code></dt>
	<dd>Retourne un booléen indiquant si la valeur testée est un tableau ou non.</dd>

	<dt><code>fn:isLiteral</code></dt>
	<dd>Retourne un booléen indiquant si la valeur testée est littérale ou non. Une valeur littérale est considérée comme définie et non comme un objet.</dd>

	<dt><code>fn:getType</code></dt>
	<dd>Renvoie le type de la valeur définie via la propriété <code>@type</code> ou son type JavaScript correspondant à l'aide de la fonction typeof.</dd>

	<dt><code>fn:guessType</code></dt>
	<dd>
		<p>Le parseur de gabarits essaiera de deviner le type de données de la valeur testée.</p>
		<p>Cette fonction de test renverra :</p>
		<ul>
			<li><code>rdfs:Container</code> lorsque la valeur est un tableau.</li>
			<li><code>rdfs:Literal</code> pour toute valeur qui est littérale. Une valeur littérale est considérée comme définie et non comme un objet.</li>
			<li><code>rdfs:Resource</code> lorsque la valeur est un objet JSON sans type de définie.</li>
			<li><code>xsd:anyURI</code> lorsque la valeur est une chaîne de caractères qui commence par une lettre et un chiffre immédiatement suivis de deux points ":" sans espaces, comme <code>https://example.com.</code></li>
			<li><code>xsd:string</code> lorsque la valeur est une chaîne de caractères qui ne semble pas être une URI.</li>
			<li><code>xsd:boolean</code>  lorsque la valeur est un booléen avec la valeur <code>true</code> ou <code>false</code>.</li>
			<li><code>xsd:double</code> lorsque la valeur est un nombre JSON.</li>
			<li>La valeur définie via la sous-propriété <code>@type</code>.</li>
			<li><code>undefined</code> lorsque la valeur est indéfinie.</li>
		</ul>
	</dd>

	<dt><code>fn:getValue</code></dt>
	<dd>Renvoie la valeur en tant que valeur testable.</dd>
</dl>

<h3>Exemple de chaque fonction de test :</h3>

<div class="row">
	<div class="col-md-6">
		<p>Démo de chaque fonction de test.</p>
		<ul data-wb-json='{
			"url": "demo/conditional-2.json",
			"streamline": true,
			"mapping": [
				{
					"template": "[data-isarray]",
					"test": "fn:isArray",
					"assess": "/alpha",
					"mapping": [
						{ "selector": "span", "value": "/alpha/0" }
					]
				},
				{
					"template": "[data-isliteral]",
					"test": "fn:isLiteral",
					"assess": "/beta",
					"mapping": [
						{ "selector": "span", "value": "/beta" }
					]
				},
				{
					"template": "[data-isliteral]",
					"test": "fn:isLiteral",
					"assess": "/gamma",
					"mapping": [
						{ "selector": "span", "value": "/gamma" }
					]
				},
				{
					"template": "[data-gettype]",
					"test": "fn:getType",
					"assess": "/delta",
					"expect": "rdfs:Resource",
					"mapping": [
						{ "selector": "span", "value": "/delta" }
					]
				},
				{
					"template": "[data-gettype]",
					"test": "fn:getType",
					"assess": "/epsilon",
					"expect": "string",
					"mapping": [
						{ "selector": "span", "value": "/epsilon" }
					]
				},
				{
					"template": "[data-gettype]",
					"test": "fn:getType",
					"assess": "/zeta",
					"expect": "boolean",
					"mapping": [
						{ "selector": "span", "value": "/text/zeta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/alpha",
					"expect": "rdfs:Container",
					"mapping": [
						{ "selector": "span", "value": "/alpha/0" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/beta",
					"expect": "rdfs:Literal",
					"mapping": [
						{ "selector": "span", "value": "/beta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/gamma",
					"expect": "rdfs:Literal",
					"mapping": [
						{ "selector": "span", "value": "/gamma" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/beta",
					"expect": "xsd:anyURI",
					"mapping": [
						{ "selector": "span", "value": "/beta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/gamma",
					"expect": "xsd:anyURI",
					"mapping": [
						{ "selector": "span", "value": "/gamma" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/eta",
					"expect": "xsd:anyURI",
					"mapping": [
						{ "selector": "span", "value": "/text/eta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/beta",
					"expect": "xsd:string",
					"mapping": [
						{ "selector": "span", "value": "/beta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/gamma",
					"expect": "xsd:string",
					"mapping": [
						{ "selector": "span", "value": "/gamma" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/eta",
					"expect": "xsd:string",
					"mapping": [
						{ "selector": "span", "value": "/text/eta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/zeta",
					"expect": "xsd:boolean",
					"mapping": [
						{ "selector": "span", "value": "/text/zeta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/theta",
					"expect": "xsd:double",
					"mapping": [
						{ "selector": "span", "value": "/text/theta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/delta",
					"expect": "rdfs:Resource",
					"mapping": [
						{ "selector": "span", "value": "/delta/@value" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/sigma",
					"expect": "rdfs:Resource",
					"mapping": [
						{ "selector": "span", "value": "/sigma/alpha" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/tau",
					"expect": "undefined",
					"mapping": [
						{ "selector": "span", "value": "/undefined" }
					]
				},
				{
					"template": "[data-getvalue]",
					"test": "fn:getValue",
					"assess": "/kappa",
					"operand": "eq",
					"expect": { "lamdba": "mu" },
					"mapping": [
						{ "selector": "span", "value": "/text/kappa" }
					]
				}
			]
		}'>
			<template data-isarray>
				<li><code>fn:isArray</code>: <span></span></li>
			</template>
			<template data-isliteral>
				<li><code>fn:isLiteral</code>: <span></span></li>
			</template>
			<template data-gettype>
				<li><code>fn:getType</code>: <span></span></li>
			</template>
			<template data-guesstype>
				<li><code>fn:guessType</code>: <span></span></li>
			</template>
			<template data-getvalue>
				<li><code>fn:getValue</code>: <span></span></li>
			</template>
		</ul>
	</div>
	<div class="col-md-6">
		<p>Résultat attendu de la démonstration précédente.</p>
		<ul>
			<li><code>fn:isArray</code>: alpha</li>
			<li><code>fn:isLiteral</code>: beta</li>
			<li><code>fn:isLiteral</code>: gamma</li>
			<li><code>fn:getType</code>: delta</li>
			<li><code>fn:getType</code>: epsilon</li>
			<li><code>fn:getType</code>: zeta</li>
			<li><code>fn:guessType</code>: alpha</li>
			<li><code>fn:guessType</code>: beta</li>
			<li><code>fn:guessType</code>: gamma</li>
			<li><code>fn:guessType</code>: eta</li>
			<li><code>fn:guessType</code>: beta</li>
			<li><code>fn:guessType</code>: gamma</li>
			<li><code>fn:guessType</code>: zeta</li>
			<li><code>fn:guessType</code>: theta</li>
			<li><code>fn:guessType</code>: delta</li>
			<li><code>fn:guessType</code>: sigma</li>
			<li><code>fn:guessType</code>: tau</li>
			<li><code>fn:getValue</code>: kappa</li>
		</ul>
	</div>
</div>

<details>
	<summary>Code source</summary>
	<pre><code>&lt;div class="row">
	&lt;div class="col-md-6">
		&lt;p>Démo de chaque fonction de test.&lt;/p>
		&lt;ul data-wb-json='{
			"url": "demo/conditional-2.json",
			"streamline": true,
			"mapping": [
				{
					"template": "[data-isarray]",
					"test": "fn:isArray",
					"assess": "/alpha",
					"mapping": [
						{ "selector": "span", "value": "/alpha/0" }
					]
				},
				{
					"template": "[data-isliteral]",
					"test": "fn:isLiteral",
					"assess": "/beta",
					"mapping": [
						{ "selector": "span", "value": "/beta" }
					]
				},
				{
					"template": "[data-isliteral]",
					"test": "fn:isLiteral",
					"assess": "/gamma",
					"mapping": [
						{ "selector": "span", "value": "/gamma" }
					]
				},
				{
					"template": "[data-gettype]",
					"test": "fn:getType",
					"assess": "/delta",
					"expect": "rdfs:Resource",
					"mapping": [
						{ "selector": "span", "value": "/delta" }
					]
				},
				{
					"template": "[data-gettype]",
					"test": "fn:getType",
					"assess": "/epsilon",
					"expect": "string",
					"mapping": [
						{ "selector": "span", "value": "/epsilon" }
					]
				},
				{
					"template": "[data-gettype]",
					"test": "fn:getType",
					"assess": "/zeta",
					"expect": "boolean",
					"mapping": [
						{ "selector": "span", "value": "/text/zeta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/alpha",
					"expect": "rdfs:Container",
					"mapping": [
						{ "selector": "span", "value": "/alpha/0" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/beta",
					"expect": "rdfs:Literal",
					"mapping": [
						{ "selector": "span", "value": "/beta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/gamma",
					"expect": "rdfs:Literal",
					"mapping": [
						{ "selector": "span", "value": "/gamma" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/beta",
					"expect": "xsd:anyURI",
					"mapping": [
						{ "selector": "span", "value": "/beta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/gamma",
					"expect": "xsd:anyURI",
					"mapping": [
						{ "selector": "span", "value": "/gamma" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/eta",
					"expect": "xsd:anyURI",
					"mapping": [
						{ "selector": "span", "value": "/text/eta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/beta",
					"expect": "xsd:string",
					"mapping": [
						{ "selector": "span", "value": "/beta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/gamma",
					"expect": "xsd:string",
					"mapping": [
						{ "selector": "span", "value": "/gamma" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/eta",
					"expect": "xsd:string",
					"mapping": [
						{ "selector": "span", "value": "/text/eta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/zeta",
					"expect": "xsd:boolean",
					"mapping": [
						{ "selector": "span", "value": "/text/zeta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/theta",
					"expect": "xsd:double",
					"mapping": [
						{ "selector": "span", "value": "/text/theta" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/delta",
					"expect": "rdfs:Resource",
					"mapping": [
						{ "selector": "span", "value": "/delta/@value" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/sigma",
					"expect": "rdfs:Resource",
					"mapping": [
						{ "selector": "span", "value": "/sigma/alpha" }
					]
				},
				{
					"template": "[data-guesstype]",
					"test": "fn:guessType",
					"assess": "/tau",
					"expect": "undefined",
					"mapping": [
						{ "selector": "span", "value": "/undefined" }
					]
				},
				{
					"template": "[data-getvalue]",
					"test": "fn:getValue",
					"assess": "/kappa",
					"operand": "eq",
					"expect": { "lamdba": "mu" },
					"mapping": [
						{ "selector": "span", "value": "/text/kappa" }
					]
				}
			]
		}'>
			&lt;template data-isarray>
				&lt;li>&lt;code>fn:isArray&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-isliteral>
				&lt;li>&lt;code>fn:isLiteral&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-gettype>
				&lt;li>&lt;code>fn:getType&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-guesstype>
				&lt;li>&lt;code>fn:guessType&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-getvalue>
				&lt;li>&lt;code>fn:getValue&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
		&lt;/ul>
	&lt;/div>
	&lt;div class="col-md-6">
		&lt;p>Résultat attendu de la démonstration précédente.&lt;/p>
		&lt;ul>
			&lt;li>&lt;code>fn:isArray&lt;/code>: alpha&lt;/li>
			&lt;li>&lt;code>fn:isLiteral&lt;/code>: beta&lt;/li>
			&lt;li>&lt;code>fn:isLiteral&lt;/code>: gamma&lt;/li>
			&lt;li>&lt;code>fn:getType&lt;/code>: delta&lt;/li>
			&lt;li>&lt;code>fn:getType&lt;/code>: epsilon&lt;/li>
			&lt;li>&lt;code>fn:getType&lt;/code>: zeta&lt;/li>
			&lt;li>&lt;code>fn:guessType&lt;/code>: alpha&lt;/li>
			&lt;li>&lt;code>fn:guessType&lt;/code>: beta&lt;/li>
			&lt;li>&lt;code>fn:guessType&lt;/code>: gamma&lt;/li>
			&lt;li>&lt;code>fn:guessType&lt;/code>: eta&lt;/li>
			&lt;li>&lt;code>fn:guessType&lt;/code>: beta&lt;/li>
			&lt;li>&lt;code>fn:guessType&lt;/code>: gamma&lt;/li>
			&lt;li>&lt;code>fn:guessType&lt;/code>: zeta&lt;/li>
			&lt;li>&lt;code>fn:guessType&lt;/code>: theta&lt;/li>
			&lt;li>&lt;code>fn:guessType&lt;/code>: delta&lt;/li>
			&lt;li>&lt;code>fn:guessType&lt;/code>: sigma&lt;/li>
			&lt;li>&lt;code>fn:guessType&lt;/code>: tau&lt;/li>
			&lt;li>&lt;code>fn:getValue&lt;/code>: kappa&lt;/li>
		&lt;/ul>
	&lt;/div>
&lt;/div></code></pre>
</details>


<h2>Fonction d'opérande</h2>
<p>Fonctions d'opérande qui vérifient la valeur testable.</p>

<dl class="dl-horizontal">
	<dt><code>softEq</code> (défaut)</dt>
	<dd>Vérifie si la valeur <strong>est équivalente</strong> à l'attente, optionnellement un tableau. Lorsqu'aucune attente n'est spécifiée, il retournera <code>true</code> si la valeur testable existe.</dd>
	<dt><code>eq</code></dt>
	<dd>Vérifie si la valeur <strong>est égale</strong> à l'attente, y compris lorsque la valeur est un objet.</dd>
	<dt><code>neq</code></dt>
	<dd>Vérifie si la valeur <strong>n'est pas égale</strong> à l'attente, y compris lorsque la valeur est un objet.</dd>
	<dt><code>in</code></dt>
	<dd>Check if the value (or array of value) is <strong>in</strong> the expectation (or array of expectation)</dd>
	<dd>Vérifie si la valeur (ou un tableau de valeurs) <strong>se trouve dans</strong> l'attente (ou un tableau d'attentes).</dd>
	<dt><code>nin</code></dt>
	<dd>Vérifie si la valeur (ou un tableau de valeurs) <strong>se ne trouve pas dans</strong> l'attente (ou un tableau d'attentes).</dd>
</dl>


<h3>Exemple d'opérande</h3>

<div class="row">
	<div class="col-md-6">
		<p>Démonstration de chaque opérande.</p>
		<ul data-wb-json='{
			"url": "demo/conditional-2.json",
			"streamline": true,
			"mapping": [
				{
					"template": "[data-eq]",
					"test": "fn:guessType",
					"assess": "/delta",
					"operand": "eq",
					"expect": "rdfs:Resource",
					"mapping": [
						{ "selector": "span", "value": "/delta/@value" }
					]
				},
				{
					"template": "[data-eq]",
					"test": "fn:getValue",
					"assess": "/kappa",
					"operand": "eq",
					"expect":  { "lamdba": "mu" },
					"mapping": [
						{ "selector": "span", "value": "/text/kappa" }
					]
				},
				{
					"template": "[data-eq]",
					"test": "fn:guessType",
					"assess": "/iota",
					"operand": "eq",
					"expect": [ "rdfs:Resource", "xsd:string" ],
					"mapping": [
						{ "selector": "span", "value": "/iota/@value" }
					]
				},
				{
					"template": "[data-neq]",
					"test": "fn:guessType",
					"assess": "/delta",
					"operand": "neq",
					"expect": "rdfs:Literal",
					"mapping": [
						{ "selector": "span", "value": "/delta/@value" }
					]
				},
				{
					"template": "[data-in]",
					"test": "fn:guessType",
					"assess": "/iota",
					"operand": "in",
					"expect": "xsd:string",
					"mapping": [
						{ "selector": "span", "value": "/iota/@value" }
					]
				},
				{
					"template": "[data-nin]",
					"test": "fn:guessType",
					"assess": "/iota",
					"operand": "nin",
					"expect": "rdfs:Literal",
					"mapping": [
						{ "selector": "span", "value": "/iota/@value" }
					]
				}

			]
		}'>
			<template data-eq>
				<li><code>eq</code>: <span></span></li>
			</template>
			<template data-neq>
				<li><code>neq</code>: <span></span></li>
			</template>
			<template data-in>
				<li><code>in</code>: <span></span></li>
			</template>
			<template data-nin>
				<li><code>nin</code>: <span></span></li>
			</template>
		</ul>
	</div>
	<div class="col-md-6">
		<p>Résultat attendu de la démonstration précédente.</p>
		<ul>
			<li><code>eq</code>: delta</li>
			<li><code>eq</code>: kappa</li>
			<li><code>eq</code>: iota</li>
			<li><code>neq</code>: delta</li>
			<li><code>in</code>: iota</li>
			<li><code>nin</code>: iota</li>
		</ul>
	</div>
</div>

<details>
	<summary>Code source</summary>
	<pre><code>&lt;div class="row">
	&lt;div class="col-md-6">
		&lt;p>Démonstration de chaque opérande.&lt;/p>
		&lt;ul data-wb-json='{
			"url": "demo/conditional-2.json",
			"streamline": true,
			"mapping": [
				{
					"template": "[data-eq]",
					"test": "fn:guessType",
					"assess": "/delta",
					"operand": "eq",
					"expect": "rdfs:Resource",
					"mapping": [
						{ "selector": "span", "value": "/delta/@value" }
					]
				},
				{
					"template": "[data-eq]",
					"test": "fn:getValue",
					"assess": "/kappa",
					"operand": "eq",
					"expect":  { "lamdba": "mu" },
					"mapping": [
						{ "selector": "span", "value": "/text/kappa" }
					]
				},
				{
					"template": "[data-eq]",
					"test": "fn:guessType",
					"assess": "/iota",
					"operand": "eq",
					"expect": [ "rdfs:Resource", "xsd:string" ],
					"mapping": [
						{ "selector": "span", "value": "/iota/@value" }
					]
				},
				{
					"template": "[data-neq]",
					"test": "fn:guessType",
					"assess": "/delta",
					"operand": "neq",
					"expect": "rdfs:Literal",
					"mapping": [
						{ "selector": "span", "value": "/delta/@value" }
					]
				},
				{
					"template": "[data-in]",
					"test": "fn:guessType",
					"assess": "/iota",
					"operand": "in",
					"expect": "xsd:string",
					"mapping": [
						{ "selector": "span", "value": "/iota/@value" }
					]
				},
				{
					"template": "[data-nin]",
					"test": "fn:guessType",
					"assess": "/iota",
					"operand": "nin",
					"expect": "rdfs:Literal",
					"mapping": [
						{ "selector": "span", "value": "/iota/@value" }
					]
				}

			]
		}'>
			&lt;template data-eq>
				&lt;li>&lt;code>eq&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-neq>
				&lt;li>&lt;code>neq&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-in>
				&lt;li>&lt;code>in&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-nin>
				&lt;li>&lt;code>nin&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
		&lt;/ul>
	&lt;/div>
	&lt;div class="col-md-6">
		&lt;p>Résultat attendu de la démonstration précédente.&lt;/p>
		&lt;ul>
			&lt;li>&lt;code>eq&lt;/code>: delta&lt;/li>
			&lt;li>&lt;code>eq&lt;/code>: kappa&lt;/li>
			&lt;li>&lt;code>eq&lt;/code>: iota&lt;/li>
			&lt;li>&lt;code>neq&lt;/code>: delta&lt;/li>
			&lt;li>&lt;code>in&lt;/code>: iota&lt;/li>
			&lt;li>&lt;code>nin&lt;/code>: iota&lt;/li>
		&lt;/ul>
	&lt;/div>
&lt;/div></code></pre>
</details>

<h2>La fonction d'association : Alternative</h2>

<p>Cette fonction d'association spéciale permet de configurer une liste d'associations où seul le premier enfant satisfaisant à la condition de test sera exécuté.</p>

<div class="row">
	<div class="col-md-6">
		<p>Démonstration de la fonction alternative.</p>
		<ul data-wb-json='{
			"url": "demo/conditional-2.json",
			"streamline": true,
			"mapping": [
				{
					"@type": "rdf:Alt",
					"mapping": [
						{
							"template": "[data-first]",
							"test": "fn:guessType",
							"assess": "/gamma",
							"expect": "rdfs:Literal",
							"mapping": [
								{ "selector": "span", "value": "/gamma" }
							]
						},
						{
							"template": "[data-second]",
							"test": "fn:guessType",
							"assess": "/eta",
							"expect": "xsd:anyURI",
							"mapping": [
								{ "selector": "span", "value": "/eta" }
							]
						}
					]
				}
			]
		}'>
			<template data-first>
				<li>Premier gabarit: <span></span></li>
			</template>
			<template data-second>
				<li>Second gabarit: <span></span></li>
			</template>

		</ul>
	</div>
	<div class="col-md-6">
		<p>Résultat attendu de la démonstration précédente.</p>
		<ul>
			<li>Premier gabarit: gamma</li>
		</ul>
	</div>
</div>

<details>
	<summary>Code source</summary>
	<pre><code>&lt;div class="row">
	&lt;div class="col-md-6">
		&lt;p>Démonstration de la fonction alternative.&lt;/p>
		&lt;ul data-wb-json='{
			"url": "demo/conditional-2.json",
			"streamline": true,
			"mapping": [
				{
					"@type": "rdf:Alt",
					"mapping": [
						{
							"template": "[data-first]",
							"test": "fn:guessType",
							"assess": "/gamma",
							"expect": "rdfs:Literal",
							"mapping": [
								{ "selector": "span", "value": "/gamma" }
							]
						},
						{
							"template": "[data-second]",
							"test": "fn:guessType",
							"assess": "/eta",
							"expect": "xsd:anyURI",
							"mapping": [
								{ "selector": "span", "value": "/eta" }
							]
						}
					]
				}
			]
		}'>
			&lt;template data-first>
				&lt;li>Premier gabarit: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-second>
				&lt;li>Second gabarit: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>

		&lt;/ul>
	&lt;/div>
	&lt;div class="col-md-6">
		&lt;p>Résultat attendu de la démonstration précédente.&lt;/p>
		&lt;ul>
			&lt;li>Premier gabarit: gamma&lt;/li>
		&lt;/ul>
	&lt;/div>
&lt;/div></code></pre>
</details>

<h2>Affichage conditionnel du contenu d'un gabarit</h2>
<p>Affiche le contenu du gabarit (<code>&lt;template&gt;</code>) sans l'utiliser pour correspondre des données JSON.</p>
<div class="row">
	<div class="col-md-6">
		<p>Démo:</p>
		<div data-wb-json='{
				"url": "demo/conditional-2.json",
				"streamline": true,
				"mapping": [
					{
						"template": "[data-show-conditional-only]",
						"test": "fn:isLiteral",
						"assess": "/beta",
						"mapping": null
					}
				]
			}'>
			<template data-show-conditional-only>
				<p>Fonctionne</p>
			</template>
		</div>
	</div>
	<div class="col-md-6">
		<p>Résultat attendu de la démonstration précédente.</p>
		<p>Fonctionne</p>
	</div>
</div>
<details>
	<summary>Source code</summary>
	<pre><code>&lt;div class=&quot;row&quot;&gt;
	&lt;div class=&quot;col-md-6&quot;&gt;
		&lt;p&gt;Démo:&lt;/p&gt;
		&lt;div data-wb-json='{
				&quot;url&quot;: &quot;demo/conditional-2.json&quot;,
				&quot;streamline&quot;: true,
				&quot;mapping&quot;: [
					{
						&quot;template&quot;: &quot;[data-show-conditional-only]&quot;,
						&quot;test&quot;: &quot;fn:isLiteral&quot;,
						&quot;assess&quot;: &quot;/beta&quot;,
						&quot;mapping&quot;: null
					}
				]
			}'&gt;
			&lt;template data-show-conditional-only&gt;
				&lt;p&gt;Fonctionne&lt;/p&gt;
			&lt;/template&gt;
		&lt;/div&gt;
	&lt;/div&gt;
	&lt;div class=&quot;col-md-6&quot;&gt;
		&lt;p&gt;Résultat attendu de la démonstration précédente.&lt;/p&gt;
		&lt;p&gt;Fonctionne&lt;/p&gt;
	&lt;/div&gt;
&lt;/div&gt;</code></pre>
</details>

<h2>Emplacement du gabarit fusionné</h2>

<p>Par défaut, lorsque la configuration n'est pas rationalisée, le contenu créé avec le gabarit initial est ajouté à l'élément.</p>
<p>For inner template, through mapping configuration, and when the plugin configuration streamline flag is on, the content created with the template are added just before that template. However, you can use the flag "append" to append from the parent element of the template.</p>
<p>Pour le gabarit interne, via la configuration d'association et lorsque l'indicateur de rationalisation de la configuration du plugin est activé, le contenu créé avec le gabarit sera ajouté juste avant ce gabarit. Cependant, vous pouvez utiliser l'indicateur "append" pour ajouter à la fin à partir de l'élément parent du gabarit.</p>

<p>Voici un exemple de rendu d'un modèle spécifié via une association par défaut.</p>
<div class="row">
	<div class="col-md-6">
		<p>Démonstration (par défaut, insertions sur place):</p>
		<ul data-wb-json='{
			"url": "demo/conditional-1.json#/list",
			"mapping": [
				{
					"template": "[data-string]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:string",
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				},
				{
					"template": "[data-double]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:double",
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				},
				{
					"template": "[data-boolean]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:boolean",
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				},
				{
					"template": "[data-anyuri]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:anyURI",
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				}
			]
		}'>
			<template data-string>
				<li><code>xsd:string</code>: <span></span></li>
			</template>
			<template data-double>
				<li><code>xsd:double</code>: <span></span></li>
			</template>
			<template data-boolean>
				<li><code>xsd:boolean</code>: <span></span></li>
			</template>
			<template data-anyuri>
				<li><code>xsd:anyURI</code>: <span></span></li>
			</template>
		</ul>
	</div>
	<div class="col-md-6">
		<p>Résultat attendu de la démonstration précédente.</p>
		<ul>
			<li><code>xsd:string</code>: string</li>
			<li><code>xsd:string</code>: second string</li>
			<li><code>xsd:double</code>: 123.45</li>
			<li><code>xsd:boolean</code>: true</li>
			<li><code>xsd:anyURI</code>: https://example.com</li>
		</ul>
	</div>
</div>

<div class="row">
	<div class="col-md-6">
		<p>Démonstration (Avec l'indicateur <code>append</code>):</p>
		<ul data-wb-json='{
			"url": "demo/conditional-1.json#/list",
			"mapping": [
				{
					"template": "[data-string]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:string",
					"append": true,
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				},
				{
					"template": "[data-double]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:double",
					"append": true,
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				},
				{
					"template": "[data-boolean]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:boolean",
					"append": true,
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				},
				{
					"template": "[data-anyuri]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:anyURI",
					"append": true,
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				}
			]
		}'>
			<template data-string>
				<li><code>xsd:string</code>: <span></span></li>
			</template>
			<template data-double>
				<li><code>xsd:double</code>: <span></span></li>
			</template>
			<template data-boolean>
				<li><code>xsd:boolean</code>: <span></span></li>
			</template>
			<template data-anyuri>
				<li><code>xsd:anyURI</code>: <span></span></li>
			</template>
		</ul>
	</div>
	<div class="col-md-6">
		<p>Résultat attendu de la démonstration précédente.</p>
		<ul>
			<li><code>xsd:string</code>: string</li>
			<li><code>xsd:double</code>: 123.45</li>
			<li><code>xsd:boolean</code>: true</li>
			<li><code>xsd:anyURI</code>: https://example.com</li>
			<li><code>xsd:string</code>: second string</li>
		</ul>
	</div>
</div>

<details>
	<summary>Code source</summary>
	<pre><code>&lt;div class="row">
	&lt;div class="col-md-6">
		&lt;p>Démonstration (par défaut, insertions sur place):&lt;/p>
		&lt;ul data-wb-json='{
			"url": "demo/conditional-1.json#/list",
			"mapping": [
				{
					"template": "[data-string]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:string",
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				},
				{
					"template": "[data-double]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:double",
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				},
				{
					"template": "[data-boolean]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:boolean",
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				},
				{
					"template": "[data-anyuri]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:anyURI",
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				}
			]
		}'>
			&lt;template data-string>
				&lt;li>&lt;code>xsd:string&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-double>
				&lt;li>&lt;code>xsd:double&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-boolean>
				&lt;li>&lt;code>xsd:boolean&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-anyuri>
				&lt;li>&lt;code>xsd:anyURI&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
		&lt;/ul>
	&lt;/div>
	&lt;div class="col-md-6">
		&lt;p>Résultat attendu de la démonstration précédente.&lt;/p>
		&lt;ul>
			&lt;li>&lt;code>xsd:string&lt;/code>: string&lt;/li>
			&lt;li>&lt;code>xsd:string&lt;/code>: second string&lt;/li>
			&lt;li>&lt;code>xsd:double&lt;/code>: 123.45&lt;/li>
			&lt;li>&lt;code>xsd:boolean&lt;/code>: true&lt;/li>
			&lt;li>&lt;code>xsd:anyURI&lt;/code>: https://example.com&lt;/li>
		&lt;/ul>
	&lt;/div>
&lt;/div>

&lt;div class="row">
	&lt;div class="col-md-6">
		&lt;p>Démonstration (Avec l'indicateur &lt;code>append&lt;/code>):&lt;/p>
		&lt;ul data-wb-json='{
			"url": "demo/conditional-1.json#/list",
			"mapping": [
				{
					"template": "[data-string]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:string",
					"append": true,
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				},
				{
					"template": "[data-double]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:double",
					"append": true,
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				},
				{
					"template": "[data-boolean]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:boolean",
					"append": true,
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				},
				{
					"template": "[data-anyuri]",
					"test": "fn:guessType",
					"assess": "/",
					"expect": "xsd:anyURI",
					"append": true,
					"mapping": [
						{ "selector": "span", "value": "/" }
					]
				}
			]
		}'>
			&lt;template data-string>
				&lt;li>&lt;code>xsd:string&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-double>
				&lt;li>&lt;code>xsd:double&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-boolean>
				&lt;li>&lt;code>xsd:boolean&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
			&lt;template data-anyuri>
				&lt;li>&lt;code>xsd:anyURI&lt;/code>: &lt;span>&lt;/span>&lt;/li>
			&lt;/template>
		&lt;/ul>
	&lt;/div>
	&lt;div class="col-md-6">
		&lt;p>Résultat attendu de la démonstration précédente.&lt;/p>
		&lt;ul>
			&lt;li>&lt;code>xsd:string&lt;/code>: string&lt;/li>
			&lt;li>&lt;code>xsd:double&lt;/code>: 123.45&lt;/li>
			&lt;li>&lt;code>xsd:boolean&lt;/code>: true&lt;/li>
			&lt;li>&lt;code>xsd:anyURI&lt;/code>: https://example.com&lt;/li>
			&lt;li>&lt;code>xsd:string&lt;/code>: second string&lt;/li>
		&lt;/ul>
	&lt;/div>
&lt;/div></code></pre>
</details>

<h2>Association de la valeur du type <code>@json</code> (ou <code>rdf:JSON</code>)</h2>

<p>Allow to display in a textual form <code>@json</code> typed value or <code>rdf:JSON</code> value which are the exact same. The test function for data type will always return the RDF form of the type <code>@json</code> which is <code>rdf:JSON</code></p>
<p>Permet d'afficher sous une forme textuel les valeur du type <code>@json</code> ou de <code>rdf:JSON</code> lequel ont exactement la même signification. La fonction d'essaie du type de donné va toujours retourné ce type sous se forme RDF. Par example, le type <code>@json</code> sera retourné comme valeur <code>rdf:JSON</code></p>


<div class="row">
	<div class="col-md-6">
		<p>Démonstration d'association d'une donnée <code>@json</code> et de <code>rdf:JSON</code></p>
		<div data-wb-json='{
			"url": "demo/conditional-2.json",
			"streamline": true,
			"mapping": [
				{
					"template": "[data-json-content]",
					"test": "fn:guessType",
					"assess": "/nu",
					"expect": "rdf:JSON",
					"mapping": [
						{ "selector": "data", "value": "/nu" },
						{ "selector": "data", "value": "/nu", "attr": "value" }
					]
				},
				{
					"template": "[data-json-content]",
					"test": "fn:guessType",
					"assess": "/rho",
					"expect": "rdf:JSON",
					"mapping": [
						{ "selector": "data", "value": "/rho" },
						{ "selector": "data", "value": "/rho", "attr": "value" }
					]
				}
			]
		}'>
			<template data-json-content>
				<pre><code><data value></data></code></pre>
			</template>
		</div>
	</div>
	<div class="col-md-6">
		<p>Résultat attendu de la démonstration précédente.</p>
		<pre><code><data value='{"xi":"xi","omicron":"omicron","pi":"pi"}'>{"xi":"xi","omicron":"omicron","pi":"pi"}</data></code></pre>
		<pre><code><data value='{"sigma":"sigma","tau":"tau","upsilon":"upsilon"}'>{"sigma":"sigma","tau":"tau","upsilon":"upsilon"}</data></code></pre>
	</div>
</div>

<details>
	<summary>Code source</summary>
	<pre><code>&lt;div class="row">
	&lt;div class="col-md-6">
		&lt;p>Démonstration d'association d'une donnée &lt;code>@json&lt;/code> et de &lt;code>rdf:JSON&lt;/code>&lt;/p>
		&lt;div data-wb-json='{
			"url": "demo/conditional-2.json",
			"streamline": true,
			"mapping": [
				{
					"template": "[data-json-content]",
					"test": "fn:guessType",
					"assess": "/nu",
					"expect": "rdf:JSON",
					"mapping": [
						{ "selector": "data", "value": "/nu" },
						{ "selector": "data", "value": "/nu", "attr": "value" }
					]
				},
				{
					"template": "[data-json-content]",
					"test": "fn:guessType",
					"assess": "/rho",
					"expect": "rdf:JSON",
					"mapping": [
						{ "selector": "data", "value": "/rho" },
						{ "selector": "data", "value": "/rho", "attr": "value" }
					]
				}
			]
		}'>
			&lt;template data-json-content>
				&lt;pre>&lt;code>&lt;data value>&lt;/data>&lt;/code>&lt;/pre>
			&lt;/template>
		&lt;/div>
	&lt;/div>
	&lt;div class="col-md-6">
		&lt;p>Résultat attendu de la démonstration précédente.&lt;/p>
		&lt;pre>&lt;code>&lt;data value='{"xi":"xi","omicron":"omicron","pi":"pi"}'>{"xi":"xi","omicron":"omicron","pi":"pi"}&lt;/data>&lt;/code>&lt;/pre>
		&lt;pre>&lt;code>&lt;data value='{"sigma":"sigma","tau":"tau","upsilon":"upsilon"}'>{"sigma":"sigma","tau":"tau","upsilon":"upsilon"}&lt;/data>&lt;/code>&lt;/pre>
	&lt;/div>
&lt;/div></code></pre>
</details>

<h2>Extension de la fonction de test et de l'opérande</h2>

<p>Le plugin data-json a été adapté pour permettre l'extension de sa fonction de test et de sa liste d'opérandes, sans possibilité de les remplacer.</p>

<script>
window[ "wb-data-json" ] = {
	functionForTest: {
		"myCustomTest": function( value, rawValue ) {
			if ( value === "beta" ) {
				return "foo";
			}
			return value;
		}
	},
	functionForOperand: {
		"myCustomOperand": function( value, expect ) {
			if ( value === "foo" && expect === "bar" ) {
				return true;
			} else {
				return false;
			}
		}
	}
};
</script>

<p data-wb-json='{
	"url": "demo/conditional-2.json",
	"streamline": true,
	"mapping": [
		{
			"template": "[data-custom]",
			"test": "myCustomTest",
			"value": "/beta",
			"operand": "myCustomOperand",
			"expect": "bar",
			"mapping": [
				{ "selector": "strong", "value": "/" }
			]
		}
	]
}'>Si la fonction de test personnalisée et l'opérande définis uniquement sur cette page sont positifs, le texte suivant sera mis en évidence avec le contenu défini sur "beta":
	<template data-custom>
		<strong></strong>
	</template>
</p>

<details>
	<summary>Code source</summary>
	<pre><code>&lt;script>
window[ "wb-data-json" ] = {
	functionForTest: {
		"myCustomTest": function( value, rawValue ) {
			if ( value === "beta" ) {
				return "foo";
			}
			return value;
		}
	},
	functionForOperand: {
		"myCustomOperand": function( value, expect ) {
			if ( value === "foo" && expect === "bar" ) {
				return true;
			} else {
				return false;
			}
		}
	}
};
&lt;/script>

&lt;p data-wb-json='{
	"url": "demo/conditional-2.json",
	"streamline": true,
	"mapping": [
		{
			"template": "[data-custom]",
			"test": "myCustomTest",
			"value": "/beta",
			"operand": "myCustomOperand",
			"expect": "bar",
			"mapping": [
				{ "selector": "strong", "value": "/" }
			]
		}
	]
}'>Si la fonction de test personnalisée et l'opérande définis uniquement sur cette page sont positifs, le texte suivant sera mis en évidence avec le contenu défini sur "beta":
	&lt;template data-custom>
		&lt;strong>&lt;/strong>
	&lt;/template>
&lt;/p></code></pre>
</details>
